Memory management in runtime environments is often devised so as to provide convenience for the software engineer. For this reason, runtime environments such as Java (Java is a Registered Trademark of Sun Microsystems Inc.) include heap memory having a garbage collector. A garbage collector is a runtime facility for automatically identifying and discarding unused data from memory, such as objects, so as to free up storage.
Garbage collection is a luxury afforded by the efficiencies of modern computer systems that serves to liberate software engineers from the task of programmatically discarding each and every unused object. It does, however, present some drawbacks. One such drawback is that the process of garbage collection generally requires the suspension of execution of software threads accessing the heap. This is because the process of identifying and discarding unused objects cannot normally be undertaken while software threads actively allocate and access existing or new objects. For the garbage collector to operate effectively, the state of the heap is to be preferably static and determinate for the duration of the garbage collection process. The duration of suspension of threads for garbage collection depends on the number and variety of data objects existing in the heap and can range from an imperceptibly short duration to periods long enough to be perceived by a user. Thus the process of garbage collection can lead to delays of indeterminate frequency and duration. These downsides render garbage collected runtime environments inherently unsuitable for software depending on continuity of execution and predictability. Such software includes critical real time applications such as those used in monitoring and control applications, and these applications are normally precluded from accessing a garbage collected memory in order to ensure their consistency and stability.
To address these downsides of garbage collected heap memory, runtime environments can be adapted to use scoped memory areas. Scoped memory areas are areas of memory suitable for the allocation and de-allocation of objects without some of the disadvantages of garbage collected heaps. A software thread can enter a scoped memory area and all object allocations by the thread will then be made within the scoped memory area. The thread can also enter multiple scoped memory areas in a nested fashion. For example, the thread can enter a second scoped memory area which becomes the default allocation area. Scoped memory areas are organised in a scope graph with each scoped memory area having a parent being the previously entered scoped memory area. A first scoped memory area has a primordial scoped memory area as its parent.
A thread count is maintained for each scoped memory area of a number of active threads in the area. The thread count coupled with the scope graph indicates when a scoped memory area, including any objects allocated in the scoped memory area, is discardable. For example a scoped memory area may be discardable when an associated thread count is decremented from one to zero and the scoped memory area is not a parent for any other scoped memory area. In this way, scoped memory areas offer alternative allocation spaces for objects in an otherwise garbage collected runtime environment, such as Java. The use of such scoped memory areas can address the problem of delays and uncertainty in application execution caused by garbage collection algorithms since all objects in scoped memory areas become discardable at the same time defined in terms of thread usage of the memory area and the organisation of a scope graph.
A first object in a first scoped memory area can reference a second object in a second scoped memory area. However, since individual scoped memory areas can become completely discardable it is necessary to enforce strict rules regarding valid and invalid references between objects in different scoped memory areas. These rules are necessary to guarantee that a parent scoped memory area has a lifetime that is at least that of its child scoped memory areas so that objects in descendant memory areas can reliably reference objects in ancestor memory areas. In this way, dangling references can be avoided. This is described in “Efficient Memory-Reference Checks for Real-time Java” (Corsaro and Cytron, ACM SIGPLAN Volume 38, Issue 7 Jul. 2003).
One such rule is that a scoped memory area has at most one parent. This is known as the “single parent rule”. The single parent rule provides that the order of entry into scoped memory areas by different threads is always the same because the order of entry of threads into scoped memory areas defines the structure of the scoped memory areas in the scope graph. Further, a source object allocated in a source scoped memory area can only reference target objects in the same or ancestral scoped memory areas. An ancestral scoped memory area is a memory area which is entered by a thread before the source scoped memory area. The source scoped memory area is said to have inner scope with respect to that of the target object. This criterion ensures that the source object will always be de-allocated before the target object. Attempts to create references which do not satisfy the criterion must fail according to the Real-Time Specification for Java (Bollella et al, Addison-Wesley, 2000). Thus the criterion must be checked in an efficient manner whenever a new reference to a target object is created.
One way to determine whether this criterion is satisfied for the creation of a reference between objects is to iterate through scoped memory areas in a scope graph. Iteration starts at the source scoped memory area and progresses through each parent scoped memory area checking for the target scoped memory area. If the target scoped memory area is encountered within the scope graph during the iterations then it can be concluded that the criterion is satisfied because the target area is an ancestor of the source area. If the iterations reach the primordial scoped memory area (the “root” of the scope graph) then it can be concluded that the criterion is not satisfied because the target scoped memory area is not an ancestor of the source scoped memory area.
An alternative approach is to determine an index of the distance between the scoped memory area of the target object and the primordial scoped memory area. This distance can be considered to be a “depth” of the target scoped memory area. Additionally, an index of the distance between the scoped memory area of the source object and the primordial scoped memory area can be determined as a “depth” of the source scope. The term depth here is used to indicate that scoped memory areas exist at levels which are some distance from the primordial scoped memory area. Deeper scoped memory areas are located at a level in the scope graph which is further from the primordial scoped memory area. A comparison of these indices of depth will determine whether the target scoped memory area is an ancestor of the source scoped memory area because descendent areas will always be deeper (further from the primordial scoped memory area) than ancestor areas. Thus, if the source scoped memory area is deeper than the target scoped memory area then the criterion is satisfied and a reference can be created.
FIG. 1 is a block diagram of an exemplary scoped memory system 100 in the prior art. The scoped memory system is an arrangement of a part of a storage of a computer system such as the scoped memory system described in the Real-Time Specification for Java (Bollella et al, Addison-Wesley, 2000). In use, the scoped memory system 100 includes a scope graph 102 which is a data structure arrangement of zero or more scoped memory areas such as scoped memory area 106. Scope graph 102 is commonly referred to in the art as a “scope stack” although the data structure of scope graph 102 is not necessarily a stack data structure. The scope graph 102 can be implemented as a directed graph data structure, a stack data structure, a tree data structure, a linked list or any data structure suitable for the storage of zero or more scoped memory areas.
Scoped memory area 106 is a defined area of memory in storage suitable for the allocation and reference of software objects. Objects can be allocated and accessed in an allocated objects 112 part of the scoped memory area by software threads which execute in the context of the scoped memory area 106. The scoped memory area 106 further includes a thread count 110 as a count of a number of software threads executing in the context of the scoped memory area 106. A thread executes in the context of the scoped memory area 106 by explicitly entering the scoped memory area, such as by calling of an application programming interface function. Once a thread has entered the scoped memory area 106, allocations of objects will be undertaken within the scoped memory area 106 unless specifically allocated elsewhere by the thread, such as in the general heap or another scoped memory area.
Scoped memory area 106 further includes a parent field 108 which includes a reference to a parent scoped memory area. As described above, a scoped memory area has at most one parent. An arrangement of scoped memory areas defined by way of a parental relationships there-between defines the scope graph 102. An initial scoped memory area having no particular parent will refer to a primordial scoped memory area 104 as its parent by way of a placeholder.
Critical software depending on continuity of execution and predictability can use scoped memory areas for the allocation of objects. Since scoped memory areas are not garbage collected, delays and uncertainty associated with garbage collection processes do not affect scoped memory or software threads using scoped memory. While this provides certainty for critical software threads, it presents the disadvantage that individual objects allocated in scoped memory are not discarded until all objects in the scoped memory are discardable. Thus scoped memory can become consumed by numerous unused objects.
It would therefore be advantageous to provide the advantages of garbage collection with the certainty and consistency of scoped memory.